\documentclass[a4paper,10pt]{report}
\usepackage[top=1.5cm, bottom=1.5cm, left=2cm, right=2cm]{geometry}

\usepackage{lmodern}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc} % Use 8-bit encoding that has 256 glyphs
\usepackage{microtype} % Slightly tweak font spacing for aesthetics

\usepackage{hyperref} % For hyperlinks in the PDF
\usepackage{hyperref}
\hypersetup{
  bookmarks=true,         % show bookmarks bar?
  unicode=false,          % non-Latin characters in Acrobat’s bookmarks
  pdfnewwindow=true,      % links in new window
  colorlinks=true,       % false: boxed links; true: colored links
  linkcolor=black,        % color of internal links (change box color with linkbordercolor)
  citecolor=magenta,        % color of links to bibliography
  filecolor=magenta,      % color of file links
  urlcolor=[rgb]{0,0,0.5}           % color of external links
}

\usepackage{multicol}
\usepackage{array}
\usepackage{lastpage}

\usepackage{fancyhdr} % Headers and footers
\pagestyle{fancy} % All pages have headers and footers
\fancyhead{} % Blank out the default header
\fancyfoot{} % Blank out the default footer
\fancyfoot[R]{\thepage/\pageref{LastPage}} % Custom footer text
\renewcommand{\headrulewidth}{0pt}

\setlength{\parindent}{0cm}
\usepackage{listings}
%\usepackage{pdfpages}
\usepackage{graphicx}
\graphicspath{ {./img/} }

\usepackage{minted} % coloration syntaxique

\usepackage{listingsutf8}
\lstdefinestyle{ShellStyle}{
  language=bash,
  breaklines=true,
  basicstyle=\footnotesize\ttfamily\color{black},
  % numbers=left,
  % numberstyle=\small,
  % numbersep=3pt,
  frame=tb,
  % columns=fullflexible,
  backgroundcolor=\color{yellow!20},
  linewidth=0.95\linewidth,
  xleftmargin=0.05\linewidth
}

\setcounter{tocdepth}{4}
%----------------------------------------------------------------------------------------

\title{\textbf{Correction du partiel de C++ de 2011}}

\begin{document}

\maketitle{}

\thispagestyle{fancy} % All pages have headers and footers

%----------------------------------------------------------------------------------------


\section*{Questions de cours}
\addcontentsline{toc}{section}{Questions de cours}

\subsubsection*{L'encapsulation}
\addcontentsline{toc}{subsection}{L'encapsulation}

Le but de l'encapsulation est de protéger de l'extérieur les informations contenues dans un objet de mauvaises manipulations qui mettraient en péril les axiomes et les propriétés comportementales de l'objet. Seules les fonctions membres permettent d'accéder et de manipuler les attributs de l'objet. L'objet est vue de l'extérieur comme une boîte noire par l'utilisateur.\cite{wikipedia-encapsulation}

\subsubsection*{L'héritage}
\addcontentsline{toc}{subsection}{L'héritage}

L'héritage est un concept de la programmation orientée objet qui permet entre aures la réutilisabilité (décomposition du système en composants) et l'adaptabilité des objets grâce au polymorphisme. Ce concept est en quelque sorte le même que celui d'un arbre généalogique. Les classes ``filles'' héritent des caractéristiques de leur(s) mère(s) mais tous les attributs de la classe ``mère'' ne sont pas forcément accessibles depuis les classes ``filles'', cela dépend de la portée de l'héritage (\texttt{private}, \texttt{protected}, \texttt{public}). \cite{wikipedia-heritage}

\subsubsection*{Quelques mots sur le polymorphisme}
\addcontentsline{toc}{subsection}{Quelques mots sur le polymorphisme}

Le polymorphisme est un concept à mettre en relation avec les fonctions membres. On parle de polymorphisme lorsqu'une fonction membre peut avoir un comportement différent selon son contexte d'appel.\\
Prenons l'exemple d'une surface géométrique. Selon si c'est un carré, un cercle, un triangle, on ne va pas calculer l'aire de la même façon.\\
Supposons maintenant que l'on crée une classe abstraite (non intanciable\footnote{Si la classe est abstraite, il nous est impossible de créer directement un objet de cette classe. Il nous sera par exemple impossible de faire : \texttt{Surface* s = new Surface();} Une classe est considérée comme abstraite à partir du moment où elle contient au moins une méthode abstraite pure $\rightarrow$ \texttt{virtual ... = 0;}}) \texttt{Surface} où l'on a déclaré une fonction membre \texttt{virtual} pour calculer l'aire. Le prototype d'un telle fonction serait le suivant :
\begin{minted}[linenos=false,frame=single,fontsize=\scriptsize]{c++}
class Surface {
  public:
    Surface(void) {};
    virtual ~Surface() {};
    
    virtual double getAire(void) const = 0;
};
\end{minted}

\textbf{= 0} signifie que la fonction est virtuelle pure, c'est-à-dire que le corps de cette fonction n'est pas défini dans cette classe mais devra l'être obligatoirement dans les classes filles.\\

Maintenant, supposons que l'on crée 2 classes, \texttt{Rectangle} et \texttt{Cercle}.
\begin{minted}[linenos=true,frame=single,fontsize=\scriptsize]{c++}
  class Rectangle : protected Surface {
    protected:
      double largeur, longueur;
      
    public:
      Rectangle(double _longueur, double _largueur);
      ~Rectangle(void);

      double getAire(void) const {
        return this->longueur * this->largeur;
      }
  };
\end{minted}

\begin{minted}[linenos=true,frame=single,fontsize=\scriptsize]{c++}
  class Cercle : protected Surface {
    protected:
      double rayon;
      
    public:
      Cercle(double _rayon);
      ~Cercle(void);

      double getAire(void) const {
        return this->rayon * this->rayon * 3.14; // pi*r^2 avec pi = 3.14
      }
  };
\end{minted}

Par cet exemple, vous voyez que le polymorphisme a permis la spécialisation d'un fonction membre à un contexte particulier.

\pagebreak

Cependant, on peut se dire \textit{Pourquoi ne pas avoir créé deux classes \texttt{Rectangle} et \texttt{Cercle} sans aucun lien de parenté et l'histoire aurait été classée, on n'aurait pas eu à parler de polymorphisme !}
\textit{Oui, mais ...} Dans certains cas d'utilisation, on ne peut qu'utiliser le polymorphisme. Ci-dessous un exemple qui illustre une utilisation du polymorphisme :
\begin{minted}[linenos=true,frame=single,fontsize=\scriptsize]{c++}

  //...

  int main(void) {
    
    Surface* tab[2];
    Rectangle r(10.0,20.0);
    Cercle c(10.0);

    /* On est bien d'accord que c'est des surfaces, du coup on peut les ranger dans un tableau de surface ;o) */
    tab[0] = &r;
    tab[1] = &c;

    for(int i=0; i<2; i++) {
      cout << "Objet " << i << ", surface = " << tab[i].getAire() << endl;
    }

    return 0;
  }

  //...

\end{minted}

\section*{Les types de variables}
\addcontentsline{toc}{section}{Les types de variables}

\begin{minted}[linenos=true,frame=single,fontsize=\scriptsize]{c++}
  int main(void) {
    
    /* tableau de caracteres -> chaine de caracteres */
    char varA[] = "filiere instrumentation";

    /* nombre flottant */
    double varB = 2.;

    /* declaration d'un nombre flottant constant qui a pour valeur varB*/
    double const varC = varB;

    /* pointeur sur flottant et pointant sur varC */
    double* varD = &varC;

    /* reference sur varB */
    double& varE = varB;

    /* pointeur constant sur un flottant
     * => la valeur de ce pointeur ne peut etre modifie, il pointera toujours sur la variable varC 
     */
    double* const varF = &varC;

    /* pointeur sur un flottant constant
     * => le valeur de ce pointeur peut changer, mais le flottant pointe ne pourra jamais etre modifie
     * par l'intermediaire de ce pointeur. En d'autres mots, on ne pourra pas faire :
     * *varF = ...;
     */
    double const* varG = varB;

    /* pointeur constant sur un float constant */
    double const* const varH = varD;

    return 0;
  }
\end{minted}

Le point le plus épineux de cette question est le sens de la déclaration selon l'emplacement du \texttt{const}. Voici un article qui parle de la déclaration avec \texttt{const} et des différents cas d'utilisation :\\
\href{http://duramecho.com/ComputerInformation/WhyHowCppConst.html}{The C++ 'const' Declaration: Why \& How}\\

Voici la partie concernant les déclarations :\\

\begin{center}
\begin{minipage}[c]{0.85\textwidth}
  \textbf{Simple Use of ‘const’}\\

  The simplest use is to declare a named constant. This was available in the ancestor of C++, C.\\
  To do this, one declares a constant as if it was a variable but add ‘const’ before it. One has to initialise it immediately in the constructor because, of course, one cannot set the value later as that would be altering it.
\end{minipage}

\begin{minipage}[c]{0.85\textwidth}
  For example,
  \begin{minted}[linenos=false,frame=none,fontsize=\scriptsize]{c++}
    const int Constant1=96;
  \end{minted}
  will create an integer constant, unimaginatively called \texttt{Constant1}, with the value 96.\\
  
  Such constants are useful for parameters which are used in the program but are do not need to be changed after the program is compiled. It has an advantage for programmers over the C preprocessor \texttt{\#define} command in that it is understood \& used by the compiler itself, not just substituted into the program text by the preprocessor before reaching the main compiler, so error messages are much more helpful.\\
  
  It also works with pointers but one has to be careful where \texttt{const} is put as that determines whether the pointer or what it points to is constant. For example,
  \begin{minted}[linenos=false,frame=none,fontsize=\scriptsize]{c++}
    const int * Constant2
  \end{minted}
  declares that \texttt{Constant2} is a variable pointer to a constant integer and
  \begin{minted}[linenos=false,frame=none,fontsize=\scriptsize]{c++}
    int const * Constant2
  \end{minted}
  is an alternative syntax which does the same, whereas
  \begin{minted}[linenos=false,frame=none,fontsize=\scriptsize]{c++}
    int * const Constant3
  \end{minted}
  declares that \texttt{Constant3} is constant pointer to a variable integer and
  \begin{minted}[linenos=false,frame=none,fontsize=\scriptsize]{c++}
    int const * const Constant4
  \end{minted}
  declares that \texttt{Constant4} is constant pointer to a constant integer.\\

  \textbf{/!\textbackslash  RULE : Basically \texttt{const} applies to whatever is on its immediate left (other than if there is nothing there in which case it applies to whatever is its immediate right).}
\end{minipage}
\end{center}

\section*{Surcharge}
\addcontentsline{toc}{section}{Surcharge}

\subsubsection*{main.cpp}
\inputminted[linenos=true,frame=single,fontsize=\scriptsize]{c++}{../src/surcharge/main.cpp}

\subsubsection*{vecteur3d.hpp}
\inputminted[linenos=true,frame=single,fontsize=\scriptsize]{c++}{../src/surcharge/vecteur3d.hpp}

\subsubsection*{vecteur3d.cpp}
\inputminted[linenos=true,frame=single,fontsize=\scriptsize]{c++}{../src/surcharge/vecteur3d.cpp}
\vspace{5mm}
Output :
\begin{lstlisting}[style=ShellStyle]
  v1 == v2
  v1 != v3
  (x,y,z) = (1.5,2.4,8.9)

\end{lstlisting}
\vspace{10mm}
1) au constructeur\\

2) Voir le code source\\

3) Syntaxe générale pour surcharger un opérateur :\\
\scriptsize\texttt{<type de retour> operator<operateur à surcharger>(<type LHS>\& right\_hand\_side)}\normalsize\\
Voir \href{http://courses.cms.caltech.edu/cs11/material/cpp/donnie/cpp-ops.html}{C++ Operator Overloading Guidelines} pour plus d'informations.\\

4) Voir le code source\\

5) Non car l'opérateur \texttt{<<} n'a pas été surchargé auparavant.\\

6) Voir code. Surcharge via une fonction \texttt{friend}. Une fonction \texttt{friend} a la particularité de pouvoir accéder aux membres privés de la classe avec laquelle elle est déclarée \texttt{friend}.

\section*{UML et héritage}
\addcontentsline{toc}{section}{UML et héritage}

\begin{figure}[h!]
  \centering
  \includegraphics[scale=0.25,angle=-90]{diagramme-de-classes.pdf}
  \caption{Diagramme de classes}
  \label{fig:diagramme-de-classes}
\end{figure}

Pour quelques rappels par rapport à la relation de composition, \href{http://en.wikipedia.org/wiki/Object_composition#UML_notation}{Wikipédia; Object composition, UML notation}.

\pagebreak

\begin{minted}[linenos=true,frame=single,fontsize=\scriptsize]{c++}
  int main(void) {
    
    classe1 varClasse1;
    classe2 varClasse2;
    classe3 varClasse3;
    classe4 varClasse4;
    classe5 varClasse5;

    return 0;
  }
\end{minted}

1) On peut utiliser la fonction membre \texttt{affichage} depuis une variable de type \texttt{classe1} car elle est déclarée \texttt{public}.\\
Par contre, on ne peut pas l'utiliser depuis une variable de type \texttt{classe3}. \texttt{classe3} n'a aucun lien de parenté avec \texttt{classe1}, seulement un lien de composition de \texttt{classe3} vers \texttt{classe1}, donc \texttt{classe1} peut utiliser la fonction membre \texttt{saisie} de \texttt{classe3} mais pas l'inverse.\\

2) Non car \texttt{modif} a été déclarée \texttt{protected} et ne peut donc être accédée depuis l'extérieur.\\

3) Voir le code source ci-dessous :
\subsubsection*{classe1.hpp}
\inputminted[linenos=true,frame=single,fontsize=\scriptsize]{c++}{../src/uml/classe1.hpp}

\subsubsection*{classe2.hpp}
\inputminted[linenos=true,frame=single,fontsize=\scriptsize]{c++}{../src/uml/classe2.hpp}

\subsubsection*{classe3.hpp}
\inputminted[linenos=true,frame=single,fontsize=\scriptsize]{c++}{../src/uml/classe3.hpp}

\subsubsection*{classe4.hpp}
\inputminted[linenos=true,frame=single,fontsize=\scriptsize]{c++}{../src/uml/classe4.hpp}

\subsubsection*{classe5.hpp}
\inputminted[linenos=true,frame=single,fontsize=\scriptsize]{c++}{../src/uml/classe5.hpp}

4) Output avec les variables \texttt{varClasse2} et \texttt{varClasse4} déclarées :

\begin{lstlisting}[style=ShellStyle]
  # creation de varClasse2
  Constructeur associe a la classe 3
  Constructeur associe a la classe 1
  Constructeur associe a la classe 2

  # creation de varClasse4
  Constructeur associe a la classe 4

\end{lstlisting}

5) Output des destructeurs avec les variables \texttt{varClasse2} et \texttt{varClasse4} déclarées :

\begin{lstlisting}[style=ShellStyle]
  # destruction de varClasse2
  Destructeur associe a la classe 2
  Destructeur associe a la classe 3
  Destructeur associe a la classe 1

  # destruction de varClasse4
  Destructeur associe a la classe 4

\end{lstlisting}

6) ??? Je dirais que c'est tout à fait possible et que dans d'autres classes aussi c'est possible mais rien de sûr. Peut être qu'il y a un piège :P


\begin{thebibliography}{99}
\bibitem[WikEnc]{wikipedia-encapsulation}
Wikipedia, l'\href{http://fr.wikipedia.org/wiki/Encapsulation_(programmation)}{encapsulation}

\bibitem[WikHer]{wikipedia-heritage}
Wikipédia, l'\href{http://fr.wikipedia.org/wiki/Héritage_(informatique)}{héritage}
\end{thebibliography}

\end{document}

